---
title: "02-抽象类与接口的结合"
created: 2025-12-02
tags:
  - Java
---
# 抽象类与接口的结合

Java 的 [[01-抽象类与接口的区别|抽象类与接口的区别]] 允许开发者创建可以部分实现的父类和完全抽象的接口：

- **抽象类**：可以有具体的方法实现，也可以有抽象方法，适用于一些方法有默认实现，而某些方法需要子类实现的场景。
- **接口**：完全是抽象的（可以有默认方法，但方法本身是抽象的），适用于不提供实现细节，仅规定行为的场景。

通过结合抽象类和接口，Java 提供了更多的灵活性，让开发者可以选择最适合场景的设计方案。

Java 中的 **抽象类** 和 **接口** 结合使用，进一步增强了灵活性，使得开发者可以根据不同场景选择最适合的设计方案。下面是抽象类与接口各自的特点，并说明它们如何结合使用。

#### **抽象类（Abstract Class）**：

- **功能**：抽象类是一个不能被实例化的类，通常用于定义一组相关类的共同特征。抽象类可以有具体的方法实现（即有方法体的实现），也可以有抽象方法（即没有方法体的声明）。子类继承抽象类时，可以重写抽象类中的抽象方法，也可以继承具体的方法实现。
- **使用场景**：当需要提供一个基础类，其中包括一些共有的实现和一些必须由子类实现的方法时，使用抽象类。例如，提供一些通用的功能（如常见方法的实现），而要求子类提供特定的实现。

#### **接口（Interface）**：

- **功能**：接口是一个完全抽象的类，它仅定义方法的签名（不提供实现）。接口用于声明类的行为规范，不涉及具体实现。Java
  8 之后，接口可以包含默认方法（提供实现），但接口仍然强调行为规范而非实现细节。
- **使用场景**：接口用于声明某种行为或功能的合同。例如，定义一组方法，这些方法的实现由不同的类提供。接口支持多实现，允许一个类实现多个接口。

#### **抽象类与接口的结合**：

1. **灵活性**：通过结合使用抽象类和接口，Java 允许开发者根据需求在行为约定和功能实现之间做出权衡。抽象类可以提供通用的行为实现，而接口可以定义行为规范，让不同类可以通过实现接口来提供不同的行为。
2. **增强的扩展性**：通过使用抽象类和接口，Java 允许系统通过扩展和实现新类来不断增加新功能，而不必修改现有代码。这有助于提高系统的可扩展性。
3. **多重继承的模拟**：通过接口，Java 模拟了多继承的功能，允许类实现多个接口，以便获得多种行为。同时，抽象类提供了功能复用，避免了代码的重复。

#### **示例：抽象类与接口的结合使用**

```java
interface Animal {
    void makeSound();
}

abstract class Mammal implements Animal {
    public void feed() {
        System.out.println("Feeding the mammal.");
    }

    // Animal's makeSound is inherited but can be overridden in subclasses
}

class Dog extends Mammal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

class Cat extends Mammal {
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();  // Outputs: Woof!
        dog.feed();       // Outputs: Feeding the mammal.

        Cat cat = new Cat();
        cat.makeSound();  // Outputs: Meow!
        cat.feed();       // Outputs: Feeding the mammal.
    }
}
```

在上面的代码中，`Mammal` 是一个抽象类，它实现了 `Animal` 接口，并且提供了 `feed()` 方法的实现。`Dog` 和 `Cat` 类继承自 `Mammal` 并实现了 `makeSound()` 方法。这种结合使得系统能够通过抽象类共享实现，而通过接口提供行为规范。

---

### **总结**

- **接口与类之间的隔离**：Java 的接口设计使得类与类之间的行为解耦，接口定义行为规范，而类实现这些行为，不依赖于继承关系。这提高了系统的灵活性和可扩展性。
- **抽象类与接口的结合**：抽象类允许提供部分实现，而接口定义行为规范。通过结合使用，Java 提供了更强的灵活性，使得开发者能够根据不同的场景选择合适的设计模式。抽象类和接口的结合使得代码复用和系统扩展变得更加容易，同时避免了多继承的复杂性。

这些特性增强了 Java 的面向对象能力，帮助开发者设计出更清晰、易于维护和扩展的系统。

## 补充：结合的最经典形态——模板方法模式

抽象类"共享实现 + 留抽象方法"的写法，有个专门的名字：**模板方法模式（Template Method）**。父类把流程骨架定死，具体步骤留给子类填空。

JDK 里最经典的例子是 `InputStream`：

```java
public abstract class InputStream {
    // 模板方法：流程骨架由父类定死，子类碰不到
    public int read(byte b[], int off, int len) {
        // ...校验参数后：
        int c = read();          // ← 只依赖这个"单字节读"的抽象方法
        if (c == -1) return -1;
        b[off] = (byte) c;
        // ...循环填满数组
    }

    public abstract int read();  // ← 子类只需要实现这一个方法
}
```

`FileInputStream`、`ByteArrayInputStream`、`SocketInputStream` 数据来源千差万别，但"把数据读进字节数组"的通用流程（校验、循环、边界处理）只在 `InputStream` 里写一遍。**子类填一个空，白得一整套流程**——这正是抽象类+接口结合的红利：接口（规范谁都能实现）+ 抽象类（骨架只写一份）。

Spring 的 `JdbcTemplate` 把这套思想用到了数据库访问上：连接获取、异常转换、资源释放这些"套路"由模板包办，你只提供"这一步怎么取数据"的回调——同一个模式，从 JDK 一路贯穿到框架层。

## 补充：什么时候用抽象类，什么时候用接口

结合上面的对比，给一个可操作的选择标准：

| 问题 | 选型 |
| --- | --- |
| 需要**共享状态/代码**给子类（字段、非 abstract 方法）？ | 抽象类（接口只能有 default，没有实例字段） |
| 只是想**定义一种能力/规范**，谁能干谁声明？ | 接口 |
| 希望**一类事物拥有多种能力**（既是 Comparable 又是 Serializable）？ | 接口（多实现是硬需求） |
| 框架扩展点，需要"填空式"扩展？ | 抽象类定骨架 + 接口定规范，二者结合 |

一句话版本：**"是什么"用继承（单选），"能做什么"用接口（多选），"套路共享"用抽象类的模板方法。**

---
⬅️ [[01-抽象类与接口的区别|抽象类与接口的区别]] 🏠 [[00-Java|00-Java]] ➡️ [[01-super关键字|super 关键字]]